package com.platform.utils;

import com.github.ltsopensource.core.commons.utils.*;
import com.github.ltsopensource.core.domain.*;
import com.github.ltsopensource.core.domain.Job;
import com.github.ltsopensource.jobclient.JobClient;
import com.github.ltsopensource.jobclient.domain.Response;
import com.platform.entity.ScheduleJobEntity;
import com.platform.utils.Constant.ScheduleStatus;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Date;

/**
 * 定时任务工具类
 *
 * @author lipengjun
 * @email 939961241@qq.com
 * @date 2016年11月30日 下午12:44:59
 */
public class ScheduleUtils {
//    private final static String JOB_NAME = "TASK_";
//
//    /**
//     * 获取触发器key
//     */
//    public static TriggerKey getTriggerKey(Long jobId) {
//        return TriggerKey.triggerKey(JOB_NAME + jobId);
//    }
//
//    /**
//     * 获取jobKey
//     */
//    public static JobKey getJobKey(Long jobId) {
//        return JobKey.jobKey(JOB_NAME + jobId);
//    }
//
//    /**
//     * 获取表达式触发器
//     */
//    public static CronTrigger getCronTrigger(Scheduler scheduler, Long jobId) {
//        try {
//            return (CronTrigger) scheduler.getTrigger(getTriggerKey(jobId));
//        } catch (SchedulerException e) {
//            throw new RRException("获取定时任务CronTrigger出现异常", e);
//        }
//    }
//
//    /**
//     * 创建定时任务
//     */
//    public static void createScheduleJob(Scheduler scheduler, ScheduleJobEntity scheduleJob) {
//        try {
//            //构建job信息
//            JobDetail jobDetail = JobBuilder.newJob(ScheduleJob.class).withIdentity(getJobKey(scheduleJob.getJobId())).build();
//
//            //表达式调度构建器
//            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
//                    .withMisfireHandlingInstructionDoNothing();
//
//            //按新的cronExpression表达式构建一个新的trigger
//            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(getTriggerKey(scheduleJob.getJobId())).withSchedule(scheduleBuilder).build();
//
//            //放入参数，运行时的方法可以获取
//            jobDetail.getJobDataMap().put(ScheduleJobEntity.JOB_PARAM_KEY, scheduleJob);
//
//            scheduler.scheduleJob(jobDetail, trigger);
//
//            //暂停任务
//            if (scheduleJob.getStatus() == ScheduleStatus.PAUSE.getValue()) {
//                pauseJob(scheduler, scheduleJob.getJobId());
//            }
//        } catch (SchedulerException e) {
//            throw new RRException("创建定时任务失败", e);
//        }
//    }
//
//    /**
//     * 更新定时任务
//     */
//    public static void updateScheduleJob(Scheduler scheduler, ScheduleJobEntity scheduleJob) {
//        try {
//            TriggerKey triggerKey = getTriggerKey(scheduleJob.getJobId());
//
//            //表达式调度构建器
//            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
//                    .withMisfireHandlingInstructionDoNothing();
//
//            CronTrigger trigger = getCronTrigger(scheduler, scheduleJob.getJobId());
//
//            //按新的cronExpression表达式重新构建trigger
//            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
//
//            //参数
//            trigger.getJobDataMap().put(ScheduleJobEntity.JOB_PARAM_KEY, scheduleJob);
//
//            scheduler.rescheduleJob(triggerKey, trigger);
//
//            //暂停任务
//            if (scheduleJob.getStatus() == ScheduleStatus.PAUSE.getValue()) {
//                pauseJob(scheduler, scheduleJob.getJobId());
//            }
//
//        } catch (SchedulerException e) {
//            throw new RRException("更新定时任务失败", e);
//        }
//    }
//
//    /**
//     * 立即执行任务
//     */
//    public static void run(Scheduler scheduler, ScheduleJobEntity scheduleJob) {
//        try {
//            //参数
//            JobDataMap dataMap = new JobDataMap();
//            dataMap.put(ScheduleJobEntity.JOB_PARAM_KEY, scheduleJob);
//
//            scheduler.triggerJob(getJobKey(scheduleJob.getJobId()), dataMap);
//        } catch (SchedulerException e) {
//            throw new RRException("立即执行定时任务失败", e);
//        }
//    }
//
//    /**
//     * 暂停任务
//     */
//    public static void pauseJob(Scheduler scheduler, Long jobId) {
//        try {
//            scheduler.pauseJob(getJobKey(jobId));
//        } catch (SchedulerException e) {
//            throw new RRException("暂停定时任务失败", e);
//        }
//    }
//
//    /**
//     * 恢复任务
//     */
//    public static void resumeJob(Scheduler scheduler, Long jobId) {
//        try {
//            scheduler.resumeJob(getJobKey(jobId));
//        } catch (SchedulerException e) {
//            throw new RRException("暂停定时任务失败", e);
//        }
//    }
//
//    /**
//     * 删除定时任务
//     */
//    public static void deleteScheduleJob(Scheduler scheduler, Long jobId) {
//        try {
//            scheduler.deleteJob(getJobKey(jobId));
//        } catch (SchedulerException e) {
//            throw new RRException("删除定时任务失败", e);
//        }
//    }


    private static JobClient jobClient = (JobClient)SpringContextUtils.getBean(JobClient.class);
    private static void submitLTSJob(com.github.ltsopensource.core.domain.Job job){
        Response response = jobClient.submitJob(job);
        System.out.println(response);
    }

    public static void orderAutoCancelJob(Integer orderId, String orderSn){
        Job job = new Job();
        job.setTaskId("orderAutoCancel_" + orderId.toString());
        job.setParam("orderId", orderId.toString());
        job.setParam("orderSn", orderSn);
        job.setTaskTrackerNodeGroup("shop_TaskTracker");
        job.setNeedFeedback(true);
        job.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        int minute = Integer.valueOf(ResourceUtil.getConfigByName("order.autoCancelMinute")).intValue();
        job.setTriggerTime(com.github.ltsopensource.core.commons.utils.DateUtils.addMinute(new Date(), minute).getTime());

        submitLTSJob(job);
    }



    public static void refreshUserLevelJob(){
        Job job = new Job();
        job.setTaskId("refreshUserLevel");
        job.setTaskTrackerNodeGroup("shop_TaskTracker");
        job.setNeedFeedback(false);
        job.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        job.setCronExpression("0 0 1 * * ?");
        Response response = jobClient.submitJob(job);
        System.out.println();
    }


    public static void refreshUserFreezeAccountJob(){
        Job job = new Job();
        job.setTaskId("refreshUserFreezeAccountJob");
        job.setTaskTrackerNodeGroup("shop_TaskTracker");
        job.setNeedFeedback(false);
        job.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        job.setCronExpression("0 0 1 * * ?");
        Response response = jobClient.submitJob(job);
        System.out.println();
    }
}
